序列
一、序列基础
1. 序列定义
序列是连续内存空间的数据存储方式，内存中存放对象地址，而非数据值。
Python序列包含：列表、元组、字符串；字典、集合不属于序列。
可变序列：列表（可增删改）
不可变序列：元组、字符串（不能修改元素）
二、列表 list【可变有序序列】
1. 列表特点
可存储任意数量、任意类型数据
长度可变，自动扩容缩容
存储元素是各个对象的内存地址
2. 四种创建方式
# 1. []直接创建
a = [10,20,"abc",True]
empty = []
# 2. list()转换可迭代对象
b = list() #空列表
b1 = list(range(10)) # [0,1,2...9]
b2 = list("hello") # ['h','e','l','l','o']
#3. range生成连续整数，配合list
# 格式：range(start,end,step)，左闭右开
c = list(range(3,71,10))
#4. 列表推导式
a = [x*2 for x in range(100) if x%9==0]
# 结果：[0, 18, 36, 54, 72, 90, 108, 126, 144, 162, 180, 198]3. 列表元素新增5种方法
| 方法 | 说明 | 是否生成新列表 | 推荐度 |
|---|---|---|---|
| append(x) | 尾部追加单个元素 | 原地修改，不新建 | ⭐⭐⭐⭐⭐ |
| extend(alist) | 尾部拼接另一个列表所有元素 | 原地修改，不新建 | ⭐⭐⭐⭐ |
| insert(index,x) | 指定索引插入元素，后续元素后移 | 原地修改，不新建 | 少用 |
| + | 列表拼接 | 生成新列表 | 大数据不推荐 |
| * | 列表重复扩展 | 生成新列表 | 适合初始化 |
#示例 lst = [20,40] lst.append(80) # [20,40,80] lst.extend([50,60]) # [20,40,80,50,60] lst.insert(2,100) # [20,40,100,80,50,60] new_lst = lst + [99] #新列表 mul_lst = [10]*3 # [10,10,10]
4. 列表删除元素
del lst[index]：删除指定索引元素pop(index)：删除并返回元素，默认删最后一位remove(x)：删除第1个匹配元素，无元素则报错clear()：清空列表内所有元素，保留列表对象
a = [10,20,30,40,50] del a[2] res = a.pop() #删除50 res2 = a.pop(1) #删除20 a.remove(30) a.clear()
5. 元素访问与统计
索引访问：
lst[下标]，下标越界报错index(x,start,end)：查找元素首 次出现下标，可限定查找区间count(x)：统计元素出现次数len(lst)：获取列表长度/ not：成员判断
arr = [10,20,30,20] print(arr.index(20)) #1 print(arr.count(20)) #2 print(20 in arr) #True
6. 切片 [start:end:step]（左闭右开）
arr = [10,20,30,40,50,60,70] arr[:] #全列表 arr[1:] #从索引1到末尾 arr[:3] #0~2索引 arr[1:6:2] #[20,40,60] arr[-3:] #倒数3个 [50,60,70] arr[::-1] #列表反转
7. 列表排序
#1. list.sort()：原地修改，无返回值 lst = [20,10,40,30] lst.sort() #升序 lst.sort(reverse=True) #降序 #2. sorted(列表)：返回新列表，原列表不变 new = sorted(lst) new_desc = sorted(lst,reverse=True) #3. reversed()：返回迭代器，不修改原列表 rev = reversed(lst) list(rev)
8. 列表复制
list1 = [30,40,50] list2 = list1 #浅引用，指向同一对象 list3 = [] + list1 #创建全新列表
9. 二维列表
#存储表格：姓名、年龄、薪资、城市 table = [ ["高小一",18,30000,"北京"], ["高小二",19,20000,"上海"], ["高小五",20,10000,"深圳"] ] #取值：深圳 print(table[2][3]) #嵌套循环遍历全表 for row in table: for col in row: print(col,end="\t") print()
三、元组 tuple【不可变有序序列】
1. 元组特点
不可变：不能增删改元素，无append/remove等方法
访问速度优于列表；可作为字典的key，列表不能
单元素必须加逗号：
(5,)，(5)是int整数
2. 创建方式
#1. ()/直接逗号
t1 = (10,20,30)
t2 = 10,20,30
single = (5,)
#2. tuple()转换可迭代对象
t3 = tuple([1,2,3])
t4 = tuple(range(3))
t5 = tuple("abc")3. 常用操作
索引、切片、index/count/len/max/min/sum和列表一致；排序只能用sorted(元组)返回新列表。
t = (20,10,30) new = sorted(t) # [10,20,30]
4. zip打包
多个可迭代对象按位置打包成元组，长度以最短序列为准
a=[10,20,30] b=[40,50,60] res = list(zip(a,b)) #[(10,40),(20,50),(30,60)]
5. 生成器推导式
(表达式 for x in 可迭代对象) → 返回生成器对象，仅能遍历一次
gen = (x*2 for x in range(5)) t = tuple(gen) #(0,2,4,6,8) t2 = tuple(gen) #() 生成器用完清空
列表&元组异同
相同点
有序序列，支持索引、切片、成员运算、count/len
均可存放任意数据类型，支持拆包赋值
不同点
列表可变(增删改)，元组不可变
列表不能做字典键，元组可以
元组占用内存更小、查询更快
四、字典 dict【无序可变键值对，非序列】
1. 字典规则
key：不可变类型（数字、字符串、元组），维一不可重复
value：任意数据类型，可重复
2. 四种创建方式
#1. {}创建
d1 = {"name":"gaoqi","age":18}
#2. dict关键字创建
d2 = dict(name="gaoqi",age=18)
#3. zip拼接键值
keys = ["name","age","job"]
vals = ["gaoqi",18,"teacher"]
d3 = dict(zip(keys,vals))
#4. fromkeys：批量建key，默认值None
d4 = dict.fromkeys(["name","age"])
cost = {"支出金额":300.15,"支出日期":"2018.10.18","支出人":"高小七"}3. 字典取值
d = {"name":"gaoqi","age":18}
#方式1：[]，键不存在报错
print(d["name"])
#方式2：get()，推荐，无键返回自定义默认值
print(d.get("gender","不存在"))
#获取所有键/值/键值对
d.keys()
d.values()
d.items()
#成员判断：判断key是否存在
print("name" in d)4. 字典增删改
d = {"name":"gaoqi","age":18}
#新增/修改：key存在则覆盖，不存在新增
d["address"] = "北京"
d["age"] = 20
#update：批量合并字典，重复key覆盖
d.update({"money":1000})
#删除
del d["name"]
age = d.pop("age") #删除并返回值
item = d.popitem() #随机删除一组键值对
d.clear() #清空5. 序列解包
d = {"name":"gaoqi","age":18,"job":"teacher"}
#默认解包key
k1,k2,k3 = d
#解包value
v1,v2,v3 = d.values()
#解包键值对
i1,i2,i3 = d.items()6. 字典嵌套列表表格
row1 = {"name":"高小一","age":18,"salary":30000,"city":"北京"}
row2 = {"name":"高小二","age":19,"salary":20000,"city":"上海"}
row3 = {"name":"高小五","age":20,"salary":10000,"city":"深圳"}
table = [row1,row2,row3]
#查询第二个人薪资
print(table[1].get("salary"))
#遍历全部薪资
for row in table:
print(row["salary"])
#遍历整张表格所有数据
for info in table:
print(info["name"],info["age"],info["salary"],info["city"])7. 字典底层原理
底层依托散列表(稀疏数组bucket)，每个bucket存key地址+value地址
存数据：
hash(key)计算哈希值→取后N位做数组下标→空位存入，拥挤则顺延查找空位查数据：同哈希算法找下标，比对hash值匹配则返回value
扩容：数组填充接近2/3自动扩容，空间换时间，查询速度极快
五、集合 set【无序可变，元素维一，非序列】
1. 集合与字典关系
集合底层基于字典实现，集合元素等同于字典的key，因此元素不可重复、必须是不可变数据。
2. 创建与增删
#创建
s = {3,5,7}
#列表转集合（自动去重）
s2 = set(["a","b","b","c"]) # {'a','b','c'}
#新增
s.add(9)
#删除
s.remove(5)
s.clear()3. 集合运算（数学集合）
a = {1,3,"sxt"}
b = {"he","it","sxt"}
#并集 | / union()
print(a | b)
#交集 & / intersection()
print(a & b)
#差集 - / difference()
print(a - b)六、代码汇总
#1.range生成[30,40,50,60,70,80]
res = list(range(30,90,10))
#2.列表推导式
arr = [x*2 for x in range(100) if x%9==0]
#3.支出字典
pay_info = {"支出金额":300.15,"支出日期":"2018.10.18","支出人":"高小七"}七、内存示意图文字描述
1. a = [100,200,300]
100、200、300分别是int对象，各拥有独立内存地址；
列表a的连续内存空间只存储三个整数对象的内存地址，不存实际数值。
2. 字典存入键值对底层
创建空字典，底层生成长度为N的稀疏数组(bucket)；
对key执行
hash()得到哈希数字；截取哈希值末尾二进制换算数组下标；
下标对应bucket为空，存入key地址、value地址；若被占用，顺延哈希偏移寻找空位；
数组填充超过2/3阈值，自动扩容生成更大散列表，迁移原有数据。
上一篇：控制语句
下一篇：python基础概念
